/*
**	Command & Conquer Generals(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : ww3d                                                         *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/ww3d2/seglinerenderer.cpp                    $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Ian_l                                                       $*
 *                                                                                             *
 *                     $Modtime:: 7/12/01 3:20p                                               $*
 *                                                                                             *
 *                    $Revision:: 3                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#if 1

#include "seglinerenderer.h"
#include "ww3d.h"
#include "rinfo.h"
#include "dx8wrapper.h"
#include "sortingrenderer.h"
#include "vp.h"
#include "vector3i.h"
#include "random.h"
#include "v3_rnd.h"


/* We have chunking logic which handles N segments at a time. To simplify the subdivision logic,
** we will ensure that N is a power of two and that N >= 2^MAX_SEGLINE_SUBDIV_LEVELS, so that the
** subdivision logic can be inside the chunking loop.
*/

#if MAX_SEGLINE_SUBDIV_LEVELS > 7
#define SEGLINE_CHUNK_SIZE (1 << MAX_SEGLINE_SUBDIV_LEVELS)
#else
#define SEGLINE_CHUNK_SIZE (128)
#endif

#define MAX_SEGLINE_POINT_BUFFER_SIZE (1 + SEGLINE_CHUNK_SIZE)
// This macro depends on the assumption that each line segment is two polys.
#define MAX_SEGLINE_POLY_BUFFER_SIZE (SEGLINE_CHUNK_SIZE * 2)




SegLineRendererClass::SegLineRendererClass(void) :
		Texture(NULL),
		Shader(ShaderClass::_PresetAdditiveSpriteShader),
		Width(0.0f),
		Color(Vector3(1,1,1)),
		Opacity(1.0f),
		SubdivisionLevel(0),
		NoiseAmplitude(0.0f),
		MergeAbortFactor(1.5f),
		TextureTileFactor(1.0f),
		LastUsedSyncTime(WW3D::Get_Sync_Time()),
		CurrentUVOffset(0.0f,0.0f),
		UVOffsetDeltaPerMS(0.0f, 0.0f),
		Bits(DEFAULT_BITS)
{

}

SegLineRendererClass::SegLineRendererClass(const SegLineRendererClass & that) :
		Texture(NULL),
		Shader(ShaderClass::_PresetAdditiveSpriteShader),
		Width(0.0f),
		Color(Vector3(1,1,1)),
		Opacity(1.0f),
		SubdivisionLevel(0),
		NoiseAmplitude(0.0f),
		MergeAbortFactor(1.5f),
		TextureTileFactor(1.0f),
		LastUsedSyncTime(that.LastUsedSyncTime),
		CurrentUVOffset(0.0f,0.0f),
		UVOffsetDeltaPerMS(0.0f, 0.0f),
		Bits(DEFAULT_BITS)
{
	*this = that;
}

SegLineRendererClass & SegLineRendererClass::operator = (const SegLineRendererClass & that)
{
	if (this != &that) {
		REF_PTR_SET(Texture,that.Texture);
		Shader = that.Shader;
		Width = that.Width;
		Color = that.Color;
		Opacity = that.Opacity;
		SubdivisionLevel = that.SubdivisionLevel;
		NoiseAmplitude = that.NoiseAmplitude;
		MergeAbortFactor = that.MergeAbortFactor;
		TextureTileFactor = that.TextureTileFactor;
		LastUsedSyncTime = that.LastUsedSyncTime;
		CurrentUVOffset = that.CurrentUVOffset;
		UVOffsetDeltaPerMS = that.UVOffsetDeltaPerMS;
		Bits = that.Bits;
	}
	return *this;
}

SegLineRendererClass::~SegLineRendererClass(void)
{
	REF_PTR_RELEASE(Texture);
}

void SegLineRendererClass::Init(const W3dEmitterLinePropertiesStruct & props)
{
	// translate the flags
	Set_Merge_Intersections(props.Flags & W3D_ELINE_MERGE_INTERSECTIONS);
	Set_Freeze_Random(props.Flags & W3D_ELINE_FREEZE_RANDOM);
	Set_Disable_Sorting(props.Flags & W3D_ELINE_DISABLE_SORTING);
	Set_End_Caps(props.Flags & W3D_ELINE_END_CAPS);

	int texture_mode = ((props.Flags & W3D_ELINE_TEXTURE_MAP_MODE_MASK) >> W3D_ELINE_TEXTURE_MAP_MODE_OFFSET);
	switch (texture_mode) 
	{
	case W3D_ELINE_UNIFORM_WIDTH_TEXTURE_MAP:
		Set_Texture_Mapping_Mode(UNIFORM_WIDTH_TEXTURE_MAP);
		break;
	case W3D_ELINE_UNIFORM_LENGTH_TEXTURE_MAP:
		Set_Texture_Mapping_Mode(UNIFORM_LENGTH_TEXTURE_MAP);		
		break;
	case W3D_ELINE_TILED_TEXTURE_MAP:
		Set_Texture_Mapping_Mode(TILED_TEXTURE_MAP);		
		break;
	};

	// install all other settings
	Set_Current_Subdivision_Level(props.SubdivisionLevel);
	Set_Noise_Amplitude(props.NoiseAmplitude);
	Set_Merge_Abort_Factor(props.MergeAbortFactor);
	Set_Texture_Tile_Factor(props.TextureTileFactor);
	Set_UV_Offset_Rate(Vector2(props.UPerSec,props.VPerSec));
}


void SegLineRendererClass::Set_Texture(TextureClass *texture)
{ 
	REF_PTR_SET(Texture,texture); 
}

TextureClass * SegLineRendererClass::Get_Texture(void) const
{
	if (Texture != NULL) {
		Texture->Add_Ref();
	}
	return Texture;
}

void SegLineRendererClass::Set_Current_UV_Offset(const Vector2 & offset)
{
	CurrentUVOffset = offset;
}

void SegLineRendererClass::Set_Texture_Tile_Factor(float factor)
{
	if (factor > 50.0f) {	///@todo: I raised this number and didn't see much difference on our min-spec. -MW
		factor = 50.0f;
		WWDEBUG_SAY(("Texture Tile Factor too large in SegLineRendererClass!\r\n"));
	} else {
		factor = MAX(factor, 0.0f);
	}
	TextureTileFactor = factor;
}

void SegLineRendererClass::Reset_Line(void)
{
	LastUsedSyncTime = WW3D::Get_Sync_Time();
	CurrentUVOffset.Set(0.0f,0.0f);
}



void SegLineRendererClass::Render
(	
	RenderInfoClass & rinfo,
	const Matrix3D & transform,
	unsigned int num_points,
	Vector3 * points,
	const SphereClass & obj_sphere
)
{
	Matrix4 view;
	DX8Wrapper::Get_Transform(D3DTS_VIEW,view);

	Matrix4 identity(true);
	DX8Wrapper::Set_Transform(D3DTS_WORLD,identity);	
	DX8Wrapper::Set_Transform(D3DTS_VIEW,identity);	

	/* 
	** Handle texture UV offset animation (done once for entire line).
	*/
	unsigned int delta = WW3D::Get_Sync_Time() - LastUsedSyncTime;
	float del = (float)delta;
	Vector2 uv_offset = CurrentUVOffset + UVOffsetDeltaPerMS * del;

	// ensure offsets are in [0, 1] range:
	uv_offset.X = uv_offset.X - floorf(uv_offset.X);
	uv_offset.Y = uv_offset.Y - floorf(uv_offset.Y);
	
	// Update state
	CurrentUVOffset = uv_offset;
	LastUsedSyncTime = WW3D::Get_Sync_Time();

	// Used later
	TextureMapMode map_mode = Get_Texture_Mapping_Mode();

	/*
	** Process line geometry:
	*/

	// This has been tweaked to produce empirically good results.
	const float parallel_factor = 0.9f;

	// We reduce the chunk size to take account of subdivision levels (so that the # of points
	// after subdivision will be no higher than the allowed maximum). We know this will not reduce
	// the chunk size below 2, since the chunk size must be at least two to the power of the
	// maximum allowable number of subdivisions. The plus 1 is because #points = #segments + 1.
	unsigned int chunk_size = (SEGLINE_CHUNK_SIZE >> SubdivisionLevel) + 1;
	if (chunk_size > num_points) chunk_size = num_points;

	// Chunk through the points (we increment by chunk_size - 1 because the last point of this
	// chunk must be reused as the first point of the next chunk. This is also the reason we stop
	// when chidx = NumPoints - 1: the last point has already been processed in the previous
	// iteration so we don't need another one).
	for (unsigned int chidx = 0; chidx < num_points - 1; chidx += (chunk_size - 1)) {
		unsigned int point_cnt = num_points - chidx;
		point_cnt = MIN(point_cnt, chunk_size);

		// We use these different loop indices (which loop INSIDE a chunk) to improve readability:
		unsigned int pidx;	// Point index
		unsigned int sidx;	// Segment index
		unsigned int iidx;	// Intersection index


		/*
		** Transform points in chunk from objectspace to eyespace:
		*/

		Vector3 xformed_pts[MAX_SEGLINE_POINT_BUFFER_SIZE];

		Matrix3D view2(	view[0].X,view[0].Y,view[0].Z,view[0].W,
								view[1].X,view[1].Y,view[1].Z,view[1].W,
								view[2].X,view[2].Y,view[2].Z,view[2].W);

#ifdef ALLOW_TEMPORARIES
		Matrix3D modelview=view2*transform;
#else
		Matrix3D modelview;
		modelview.mul(view2, transform);
#endif

		VectorProcessorClass::Transform(&xformed_pts[0],
			&points[chidx], modelview, point_cnt);


		/*
		** Prepare v parameter per point - used for texture mapping (esp. tiled mapping mode)
		*/

		float base_tex_v[MAX_SEGLINE_POINT_BUFFER_SIZE];
		float u_values[2];
		switch (map_mode) {
			case UNIFORM_WIDTH_TEXTURE_MAP:
				for (pidx = 0; pidx < point_cnt; pidx++) {
					// All 0
					base_tex_v[pidx] = 0.0f;
				}
				u_values[0] = 0.0f;
				u_values[1] = 1.0f;
				break;
			case UNIFORM_LENGTH_TEXTURE_MAP:
				for (pidx = 0; pidx < point_cnt; pidx++) {
					// Increasing V
					base_tex_v[pidx] = (float)(pidx + chidx) * TextureTileFactor;
				}
				u_values[0] = 0.0f;
				u_values[1] = 0.0f;
				break;
			case TILED_TEXTURE_MAP:
				for (pidx = 0; pidx < point_cnt; pidx++) {
					// Increasing V
					base_tex_v[pidx] = (float)(pidx + chidx) * TextureTileFactor;
				}
				u_values[0] = 0.0f;
				u_values[1] = 1.0f;
				break;
		}


		/*
		** Fractal noise recursive subdivision:
		** We find the midpoint for each section, apply a random offset, and recurse. We also find
		** the average V coordinate of the endpoints which is the midpoint V (for tiled texture
		** mapping).
		*/

		Vector3 xformed_subdiv_pts[MAX_SEGLINE_POINT_BUFFER_SIZE];
		float subdiv_tex_v[MAX_SEGLINE_POINT_BUFFER_SIZE];
		unsigned int sub_point_cnt;

		subdivision_util(point_cnt, xformed_pts, base_tex_v, &sub_point_cnt, xformed_subdiv_pts, subdiv_tex_v);

		// Start using subdivided points from now on
		Vector3 *points = xformed_subdiv_pts;
		float *tex_v = subdiv_tex_v;
		point_cnt = sub_point_cnt;


		/*
		** Calculate line segment edge planes:
		*/

		// For each line segment find the two silhouette planes from eyepoint to the line segment
		// cylinder. To simplify we do not find the tangent planes but intersect the cylinder with a
		// plane passing through its axis and perpendicular to the eye vector, find the edges of the
		// resulting rectangle, and create planes through these edges and the eyepoint.
		// Note that these planes are represented as a single normal rather than a normal and a
		// distance; this is because they pass through the origin (eyepoint) so their distance is
		// always zero.

		// Since the line has thickness, each segment has two edges. We name these 'top' and
		// 'bottom' - note however that the top/bottom distinction does not relate to screen
		// up/down and remains consistent throughout the segmented line.
		enum SegmentEdge {
			FIRST_EDGE     = 0,	// For loop conditions
			TOP_EDGE			= 0,	// Top Edge
			BOTTOM_EDGE		= 1,	// Bottom Edge
			MAX_EDGE			= 1,	// For loop conditions
			NUM_EDGES		= 2	// For array allocations
		};

		bool switch_edges = false;
		
		// We have dummy segments for "before the first point" and "after the last point" - in these
		// segments the top and bottom edge are the same - they are a perpendicular plane defined by
		// the endpoint vertices. This is so we can merge intersections properly for the first and
		// last points.

		struct LineSegment {
			Vector3	StartPlane;
			Vector3	EdgePlane[NUM_EDGES];
		};

		// # segments = numpoints + 1 (numpoints - 1, plus two dummy segments)
		LineSegment segment[MAX_SEGLINE_POINT_BUFFER_SIZE + 1];

		// Intersections. This has data for two edges (top or bottom) intersecting.
		struct LineSegmentIntersection  {
			unsigned int	PointCount;			// How many points does this intersection represent
			unsigned int	NextSegmentID;		// ID of segment after this intersection
			Vector3			Direction;			// Calculated intersection direction line
			Vector3			Point;				// Averaged 3D point on the line which this represents
			float				TexV;					// Averaged texture V coordinate of points
			bool				Fold;					// Does the line fold over at this intersection?
			bool				Parallel;			// Edges at this intersection are parallel (or almost-)
		};

		// Used to calculate the edge planes
		float radius = Width * 0.5f;

		// The number of intersections is the number of points minus 2. However, we store
		// intersection records for the first and last point, even though they are not really
		// intersections. The reason we do this is for the intersection merging - the vertices for
		// the first and last points can get merged just like any other intersection. Also, we have
		// a dummy intersection record before the first point - this is because we want "previous
		// segments" for the first point and each intersection only has an index for the next
		// segment.
		LineSegmentIntersection intersection[MAX_SEGLINE_POINT_BUFFER_SIZE + 1][NUM_EDGES];

		for (sidx = 1; sidx < point_cnt; sidx++) {	// #segments = #points - 1 (+ 2 dummy segments)

			Vector3 &curr_point = points[sidx - 1];
			Vector3 &next_point = points[sidx];

			// We temporarily store the segment direction in the segment's StartPlane (since it is
			// used to calculate the StartPlane later).
			Vector3 &segdir = segment[sidx].StartPlane;
			segdir = next_point - curr_point;
			segdir.Normalize();

			// Find nearest point on infinite line to eye (origin)
			Vector3 nearest = curr_point + segdir * -Vector3::Dot_Product(segdir, curr_point);

			// Find top and bottom points on cylinder
			Vector3 offset;
			Vector3::Cross_Product(segdir, nearest, &offset);
			offset.Normalize();
			Vector3 top = curr_point + offset * radius;
			Vector3 bottom = curr_point + offset * -radius;

			// Find planes through top/bottom points and eyepoint. In addition to the two points, we
			// know that the planes are parallel to the line segment.
			Vector3 top_normal;
			Vector3::Cross_Product(top, segdir, &top_normal);
			top_normal.Normalize();
			segment[sidx].EdgePlane[TOP_EDGE] = top_normal;

			Vector3 bottom_normal;
			Vector3::Cross_Product(segdir, bottom, &bottom_normal);
			bottom_normal.Normalize();
			segment[sidx].EdgePlane[BOTTOM_EDGE] = bottom_normal;

			// If the visual angle between the previous and current line segments (we use the angle
			// between the planes defined by each line segment and the eyepoint) is less than 90
			// degrees, switch the top and bottom edges for the current and subsequent segments and
			// mark the intersection as having a fold
			if (sidx > 1) {

				Vector3 prev_plane;
				Vector3::Cross_Product(points[sidx - 2], curr_point, &prev_plane);
				prev_plane.Normalize();

				Vector3 curr_plane;
				Vector3::Cross_Product(curr_point, next_point, &curr_plane);
				curr_plane.Normalize();

				if (Vector3::Dot_Product(prev_plane, curr_plane) < 0.0f) {
					switch_edges = !switch_edges;
					intersection[sidx][TOP_EDGE].Fold = true;
					intersection[sidx][BOTTOM_EDGE].Fold = true;
				} else {
					intersection[sidx][TOP_EDGE].Fold = false;
					intersection[sidx][BOTTOM_EDGE].Fold = false;
				}
			}

			if (switch_edges) {
				// We switch signs so the normals will always point inwards
				segment[sidx].EdgePlane[TOP_EDGE] = -bottom_normal;
				segment[sidx].EdgePlane[BOTTOM_EDGE] = -top_normal;
			}

		}

		// The two dummy segments for the clipping edges of the first and last real segments will be
		// defined later, with the first and last intersections.


		/*
		** Calculate segment edge intersections:
		*/

		unsigned int numsegs = point_cnt - 1;	// Doesn't include the two dummy segments
		unsigned int num_intersections[NUM_EDGES];

		// These include the 1st, last point "intersections", not the pre-first dummy intersection
		num_intersections[TOP_EDGE] = point_cnt;
		num_intersections[BOTTOM_EDGE] = point_cnt;

		// Initialize pre-first point dummy intersection record (only NextSegmentID will be used).
		intersection[0][TOP_EDGE].PointCount = 0;				// Should never be used
		intersection[0][TOP_EDGE].NextSegmentID = 0;			// Points to first dummy segment
		intersection[0][TOP_EDGE].Direction.Set(1,0,0);		// Should never be used
		intersection[0][TOP_EDGE].Point.Set(0,0,0);			// Should never be used
		intersection[0][TOP_EDGE].TexV = 0.0f;					// Should never be used
		intersection[0][TOP_EDGE].Fold = true;					// Should never be used
		intersection[0][TOP_EDGE].Parallel = false;			// Should never be used
		intersection[0][BOTTOM_EDGE].PointCount = 0;			// Should never be used
		intersection[0][BOTTOM_EDGE].NextSegmentID = 0;		// Points to first dummy segment
		intersection[0][BOTTOM_EDGE].Point.Set(0,0,0);		// Should never be used
		intersection[0][BOTTOM_EDGE].TexV = 0.0f;				// Should never be used
		intersection[0][BOTTOM_EDGE].Direction.Set(1,0,0);	// Should never be used
		intersection[0][BOTTOM_EDGE].Fold = true;				// Should never be used
		intersection[0][BOTTOM_EDGE].Parallel = false;		// Should never be used

		// Initialize first point "intersection" record.
		intersection[1][TOP_EDGE].PointCount = 1;
		intersection[1][TOP_EDGE].NextSegmentID = 1;
		intersection[1][TOP_EDGE].Point = points[0];
		intersection[1][TOP_EDGE].TexV = tex_v[0];
		intersection[1][TOP_EDGE].Fold = true;
		intersection[1][TOP_EDGE].Parallel = false;
		intersection[1][BOTTOM_EDGE].PointCount = 1;
		intersection[1][BOTTOM_EDGE].NextSegmentID = 1;
		intersection[1][BOTTOM_EDGE].Point = points[0];
		intersection[1][BOTTOM_EDGE].TexV = tex_v[0];
		intersection[1][BOTTOM_EDGE].Fold = true;
		intersection[1][BOTTOM_EDGE].Parallel = false;

		// Find closest point to 1st top/bottom segment edge plane, and convert to direction vector
		// and dummy segment edge plane.

		Vector3 top;
		Vector3 bottom;

		Vector3 &first_point = points[0];
		Vector3 *first_plane = &(segment[1].EdgePlane[0]);
		top = first_point - first_plane[TOP_EDGE] * Vector3::Dot_Product(first_plane[TOP_EDGE], first_point);
		top.Normalize();
		intersection[1][TOP_EDGE].Direction = top;
		bottom = first_point - first_plane[BOTTOM_EDGE] * Vector3::Dot_Product(first_plane[BOTTOM_EDGE], first_point);
		bottom.Normalize();
		intersection[1][BOTTOM_EDGE].Direction = bottom;
		
		Vector3 segdir = points[1] - points[0];
		segdir.Normalize();	// Is this needed? Probably not - remove later when all works
		Vector3 start_pl;
		Vector3::Cross_Product(top, bottom, &start_pl);
		start_pl.Normalize();
		float dp = Vector3::Dot_Product(segdir, start_pl);
		if (dp > 0.0f) {
			segment[0].StartPlane = segment[0].EdgePlane[TOP_EDGE] = segment[0].EdgePlane[BOTTOM_EDGE] = start_pl;
		} else {
			segment[0].StartPlane = segment[0].EdgePlane[TOP_EDGE] = segment[0].EdgePlane[BOTTOM_EDGE] = -start_pl;
		}

		// Initialize StartPlane for the first "real" segment
		segment[1].StartPlane = segment[0].StartPlane;

		// Initialize last point "intersection" record.
		unsigned int last_isec = num_intersections[TOP_EDGE]; // Same # top, bottom intersections

		intersection[last_isec][TOP_EDGE].PointCount = 1;
		intersection[last_isec][TOP_EDGE].NextSegmentID = numsegs + 1; // Last dummy segment
		intersection[last_isec][TOP_EDGE].Point = points[point_cnt - 1];
		intersection[last_isec][TOP_EDGE].TexV = tex_v[point_cnt - 1];
		intersection[last_isec][TOP_EDGE].Fold = true;
		intersection[last_isec][TOP_EDGE].Parallel = false;
		intersection[last_isec][BOTTOM_EDGE].PointCount = 1;
		intersection[last_isec][BOTTOM_EDGE].NextSegmentID = numsegs + 1;// Last dummy segment
		intersection[last_isec][BOTTOM_EDGE].Point = points[point_cnt - 1];
		intersection[last_isec][BOTTOM_EDGE].TexV = tex_v[point_cnt - 1];
		intersection[last_isec][BOTTOM_EDGE].Fold = true;
		intersection[last_isec][BOTTOM_EDGE].Parallel = false;

		// Find closest point to last top/bottom segment edge plane, and convert to direction vector
		// and dummy segment edge vector

		Vector3 &last_point = points[point_cnt - 1];
		Vector3 *last_plane = &(segment[numsegs].EdgePlane[0]);
		top = last_point - last_plane[TOP_EDGE] * Vector3::Dot_Product(last_plane[TOP_EDGE], last_point);
		top.Normalize();
		intersection[last_isec][TOP_EDGE].Direction = top;
		bottom = last_point - last_plane[BOTTOM_EDGE] * Vector3::Dot_Product(last_plane[BOTTOM_EDGE], last_point);
		bottom.Normalize();
		intersection[last_isec][BOTTOM_EDGE].Direction = bottom;
		
		segdir = points[point_cnt - 1] - points[point_cnt - 2];
		segdir.Normalize();	// Is this needed? Probably not - remove later when all works
		Vector3::Cross_Product(top, bottom, &start_pl);
		start_pl.Normalize();
		dp = Vector3::Dot_Product(segdir, start_pl);
		if (dp > 0.0f) {
			segment[numsegs + 1].StartPlane = segment[numsegs + 1].EdgePlane[TOP_EDGE] =
				segment[numsegs + 1].EdgePlane[BOTTOM_EDGE] = start_pl;
		} else {
			segment[numsegs + 1].StartPlane = segment[numsegs + 1].EdgePlane[TOP_EDGE] =
				segment[numsegs + 1].EdgePlane[BOTTOM_EDGE] = -start_pl;
		}

		// Calculate midpoint segment intersections. There are 2 segment intersections for each
		// point: top and bottom (due to the fact that the segments have width, so they have a top
		// edge and a bottom edge). Note that the top/bottom distinction does not relate to screen
		// up/down. Since each segment edge is represented by a plane passing through the origin
		// (eyepoint), the intersection of two such is a line passing through the origin, which is
		// represented as a normalized direction vector.
		// We use both segment intersections to define the startplane for the segment which begins
		// at that intersection.

		float vdp;

		for (iidx = 2; iidx < num_intersections[TOP_EDGE]; iidx++) {

			// Relevant midpoint:
			Vector3 &midpoint = points[iidx - 1];
			float mid_tex_v = tex_v[iidx - 1];

			// Initialize misc. fields
			intersection[iidx][TOP_EDGE].PointCount = 1;
			intersection[iidx][TOP_EDGE].NextSegmentID = iidx;
			intersection[iidx][TOP_EDGE].Point = midpoint;
			intersection[iidx][TOP_EDGE].TexV = mid_tex_v;
			intersection[iidx][BOTTOM_EDGE].PointCount = 1;
			intersection[iidx][BOTTOM_EDGE].NextSegmentID = iidx;
			intersection[iidx][BOTTOM_EDGE].Point = midpoint;
			intersection[iidx][BOTTOM_EDGE].TexV = mid_tex_v;

			// Intersection calculation: if the top/bottom planes of both adjoining segments are not
			// very close to being parallel, intersect them to get top/bottom intersection lines. If
			// the planes are almost parallel, pick one, find the point on the plane closest to the
			// midpoint, and convert that point to a line direction vector.

			// Top:
			vdp = Vector3::Dot_Product(segment[iidx - 1].EdgePlane[TOP_EDGE], segment[iidx].EdgePlane[TOP_EDGE]);
			if (fabs(vdp) < parallel_factor) {

				// Not parallel - intersect planes to get line (get vector, normalize it, ensure it is
				// pointing towards the midpoint)
				Vector3::Cross_Product(segment[iidx - 1].EdgePlane[TOP_EDGE], segment[iidx].EdgePlane[TOP_EDGE],
					&(intersection[iidx][TOP_EDGE].Direction));
				intersection[iidx][TOP_EDGE].Direction.Normalize();
				if (Vector3::Dot_Product(intersection[iidx][TOP_EDGE].Direction, midpoint) < 0.0f) {
					intersection[iidx][TOP_EDGE].Direction = -intersection[iidx][TOP_EDGE].Direction;
				}

				intersection[iidx][TOP_EDGE].Parallel = false;

			} else {

				// Parallel (or almost): find point on av. plane closest to midpoint, convert to line

				// Ensure average calculation is numerically stable:
				Vector3 pl;
				if (vdp > 0.0f) {
					pl = segment[iidx - 1].EdgePlane[TOP_EDGE] + segment[iidx].EdgePlane[TOP_EDGE];
				} else {
					pl = segment[iidx - 1].EdgePlane[TOP_EDGE] - segment[iidx].EdgePlane[TOP_EDGE];
				}
				pl.Normalize();

				intersection[iidx][TOP_EDGE].Direction = midpoint - pl * Vector3::Dot_Product(pl, midpoint);
				intersection[iidx][TOP_EDGE].Direction.Normalize();

				intersection[iidx][TOP_EDGE].Parallel = true;
			}

			// Bottom:
			vdp = Vector3::Dot_Product(segment[iidx - 1].EdgePlane[BOTTOM_EDGE], segment[iidx].EdgePlane[BOTTOM_EDGE]);
			if (fabs(vdp) < parallel_factor) {

				// Not parallel - intersect planes to get line (get vector, normalize it, ensure it is
				// pointing towards the midpoint)
				Vector3::Cross_Product(segment[iidx - 1].EdgePlane[BOTTOM_EDGE], segment[iidx].EdgePlane[BOTTOM_EDGE],
					&(intersection[iidx][BOTTOM_EDGE].Direction));
				intersection[iidx][BOTTOM_EDGE].Direction.Normalize();
				if (Vector3::Dot_Product(intersection[iidx][BOTTOM_EDGE].Direction, midpoint) < 0.0f) {
					intersection[iidx][BOTTOM_EDGE].Direction = -intersection[iidx][BOTTOM_EDGE].Direction;
				}

				intersection[iidx][BOTTOM_EDGE].Parallel = false;

			} else {

				// Parallel (or almost): find point on av. plane closest to midpoint, convert to line

				// Ensure average calculation is numerically stable:
				Vector3 pl;
				if (vdp > 0.0f) {
					pl = segment[iidx - 1].EdgePlane[BOTTOM_EDGE] + segment[iidx].EdgePlane[BOTTOM_EDGE];
				} else {
					pl = segment[iidx - 1].EdgePlane[BOTTOM_EDGE] - segment[iidx].EdgePlane[BOTTOM_EDGE];
				}
				pl.Normalize();

				intersection[iidx][BOTTOM_EDGE].Direction = midpoint - pl * Vector3::Dot_Product(pl, midpoint);
				intersection[iidx][BOTTOM_EDGE].Direction.Normalize();

				intersection[iidx][BOTTOM_EDGE].Parallel = true;
			}

			// Find StartPlane:
			Vector3::Cross_Product(intersection[iidx][TOP_EDGE].Direction, intersection[iidx][BOTTOM_EDGE].Direction, &start_pl);
			start_pl.Normalize();
			dp = Vector3::Dot_Product(segment[iidx].StartPlane, start_pl);
			if (dp > 0.0f) {
				segment[iidx].StartPlane = start_pl;
			} else {
				segment[iidx].StartPlane = -start_pl;
			}

		}	// for iidx


		/*
		** Intersection merging: when an intersection is inside an adjacent segment and certain
		** other conditions hold true, we need to merge intersections to avoid visual glitches
		** caused by the polys folding over on themselves.
		*/

		if (Is_Merge_Intersections()) {

			// Since we are merging the intersections in-place, we have two index variables, a "read
			// index" and a "write index".
			unsigned int iidx_r;
			unsigned int iidx_w;

			// The merges will be repeated in multiple passes until none are performed. The reason
			// for this is that one merge may cause the need for another merge elsewhere.
			bool merged = true;
			
			while (merged) {

				merged = false;

				SegmentEdge edge;
				for (edge = FIRST_EDGE; edge <= MAX_EDGE; edge = (SegmentEdge)((int)edge + 1)) {
					// Merge top and bottom edge intersections: loop through the intersections from the
					// first intersection to the penultimate intersection, for each intersection check
					// if it needs to be merged with the next one (which is why the loop doesn't go all
					// the way to the last intersection). We start at 1 because 0 is the dummy
					// "pre-first-point" intersection.
					unsigned int num_isects = num_intersections[edge];	// Capture here because will change inside loop
					for (iidx_r = 1, iidx_w = 1; iidx_r < num_isects; iidx_r++, iidx_w++) {

						// Check for either of two possible reasons to merge this intersection with the
						// next: either the segment on the far side of the next intersection overlaps
						// this intersection, or the previous segment overlaps the next intersection.
						// Note that some other conditions need to be true as well.

						// Note: iidx_r is used for anything at or after the current position, iidx_w is
						// used for anything before the current position (previous positions have
						// potentially already been merged).
						// Note: iidx_r is used for anything at or after the current position, iidx_w is
						// used for anything before the current position (previous positions have
						// potentially already been merged).
						LineSegmentIntersection *curr_int = &(intersection[iidx_r][edge]);
						LineSegmentIntersection *next_int = &(intersection[iidx_r + 1][edge]);
						LineSegmentIntersection *write_int = &(intersection[iidx_w][edge]);
						LineSegmentIntersection *prev_int = &(intersection[iidx_w - 1][edge]);
						LineSegment *next_seg = &(segment[next_int->NextSegmentID]);
						LineSegment *curr_seg = &(segment[curr_int->NextSegmentID]);
						LineSegment *prev_seg = &(segment[prev_int->NextSegmentID]);

						// If this intersection is inside both the start plane and the segment edge
						// plane of the segment after the next intersection, merge this edge
						// intersection and the next. We repeat merging until no longer needed.
						// NOTE - we do not merge across a fold.
						while	(	(!next_int->Fold &&
										(Vector3::Dot_Product(curr_int->Direction, next_seg->StartPlane) > 0.0f) &&
										(Vector3::Dot_Product(curr_int->Direction, next_seg->EdgePlane[edge]) > 0.0f )) ||
									(!curr_int->Fold &&
										(Vector3::Dot_Product(next_int->Direction, -curr_seg->StartPlane) > 0.0f) &&
										(Vector3::Dot_Product(next_int->Direction, prev_seg->EdgePlane[edge]) > 0.0f )) ) {

							// First calculate location of merged intersection - this is so we can abort
							// the merge if it yields funky results.

							// Find mean point (weighted so all points have same weighting)
							unsigned int new_count = curr_int->PointCount + next_int->PointCount;
							float oo_new_count = 1.0f / (float)new_count;
							float curr_factor = oo_new_count * (float)curr_int->PointCount;
							float next_factor = oo_new_count * (float)curr_int->PointCount;
							Vector3 new_point = curr_int->Point * curr_factor + next_int->Point * next_factor;
							float new_tex_v = curr_int->TexV * curr_factor + next_int->TexV * next_factor;

							// Calculate new intersection direction by intersecting prev_seg with next_seg
							bool new_parallel;
							Vector3 new_direction;
							vdp = Vector3::Dot_Product(prev_seg->EdgePlane[edge], next_seg->EdgePlane[edge]);
							if (fabs(vdp) < parallel_factor) {

								// Not parallel - intersect planes to get line (get vector, normalize it,
								// ensure it is pointing towards the current point)
								Vector3::Cross_Product(prev_seg->EdgePlane[edge], next_seg->EdgePlane[edge], &new_direction);
								new_direction.Normalize();
								if (Vector3::Dot_Product(new_direction, new_point) < 0.0f) {
									new_direction = -new_direction;
								}

								new_parallel = false;

							} else {

								// Parallel (or almost). If the current intersection is not parallel, take
								// the average plane and intersect it with the skipped plane. If the
								// current intersection is parallel, find the average plane, and find the
								// direction vector on it closest to the current intersections direction
								// vector.

								// Ensure average calculation is numerically stable:
								Vector3 pl;
								if (vdp > 0.0f) {
									pl = prev_seg->EdgePlane[edge] + next_seg->EdgePlane[edge];
								} else {
									pl = prev_seg->EdgePlane[edge] - next_seg->EdgePlane[edge];
								}
								pl.Normalize();

								if (curr_int->Parallel) {
									new_direction = new_direction - pl * Vector3::Dot_Product(pl, new_direction);
									new_direction.Normalize();
								} else {
									Vector3::Cross_Product(curr_seg->EdgePlane[edge], pl, &new_direction);
									new_direction.Normalize();
								}

								new_parallel = true;
							}

							// Now check to see if the merge caused any funky results - if so abort it.
							// Currently we check to see if the distance of the direction from the two
							// points is larger than the radius times the merge_abort factor.
							if (MergeAbortFactor > 0.0f) {
								float abort_dist = radius * MergeAbortFactor;
								float abort_dist2 = abort_dist * abort_dist;
								Vector3 diff_curr = curr_int->Point -
									new_direction * Vector3::Dot_Product(curr_int->Point, new_direction);
								if (diff_curr.Length2() > abort_dist2) break;
								Vector3 next_curr = next_int->Point -
									new_direction * Vector3::Dot_Product(next_int->Point, new_direction);
								if (next_curr.Length2() > abort_dist2) break;
							}

							// Merge edge intersections (curr_int and next_int) into curr_int
							merged = true;

							curr_int->Direction = new_direction;
							curr_int->Parallel = new_parallel;
							curr_int->Point = new_point;
							curr_int->TexV = new_tex_v;
							curr_int->PointCount = new_count;
							curr_int->NextSegmentID = next_int->NextSegmentID;
							curr_int->Fold = curr_int->Fold || next_int->Fold;

							// Decrement number of edge intersections
							num_intersections[edge]--;

							// Advance iidx_r to shift subsequent entries backwards in result.
							iidx_r++;

							// If we are at the end then break:
							if (iidx_r == num_isects) {
								break;
							}

							// Advance next_int and next_seg.
							next_int = &(intersection[iidx_r + 1][edge]);
							next_seg = &(segment[next_int->NextSegmentID]);

						}	// while <merging needed>

						// Copy from "read index" to "write index"
						write_int->PointCount		= curr_int->PointCount;
						write_int->NextSegmentID	= curr_int->NextSegmentID;
						write_int->Point				= curr_int->Point;
						write_int->TexV				= curr_int->TexV;
						write_int->Direction			= curr_int->Direction;
						write_int->Fold				= curr_int->Fold;

					}	// for iidx

					// If iidx_r is exactly equal to num_isects (rather than being larger by one) at this
					// point, this means that the last intersection was not merged with the previous one. In
					// this case, we need to do one last copy:
					if (iidx_r == num_isects) {
						LineSegmentIntersection *write_int = &(intersection[iidx_w][edge]);
						LineSegmentIntersection *curr_int = &(intersection[iidx_r][edge]);
						write_int->PointCount		= curr_int->PointCount;
						write_int->NextSegmentID	= curr_int->NextSegmentID;
						write_int->Point				= curr_int->Point;
						write_int->TexV				= curr_int->TexV;
						write_int->Direction			= curr_int->Direction;
						write_int->Fold				= curr_int->Fold;
					}

#ifdef ENABLE_WWDEBUGGING
					// Testing code - ensure total PointCount fits the number of points
					unsigned int total_cnt = 0;
					for (unsigned int nidx = 0; nidx <= num_intersections[edge]; nidx++) {
						total_cnt += intersection[nidx][edge].PointCount;
					}
					assert(total_cnt == point_cnt);
#endif

				}	// for edge
			}	// while (merged)
		}	// if (Is_Merge_Intersections())

		/*
		** Find vertex positions, generate vertices and triangles:
		** Since we can have top/bottom intersections merged, we need to skip points if both the top
		** and bottom intersections are merged, generate triangle fans if one of the sides is merged
		** and the other isnt, and generate triangle strips otherwise.
		*/

		// Configure vertex array and setup renderer.
		unsigned int vnum = num_intersections[TOP_EDGE] + num_intersections[BOTTOM_EDGE];		
		VertexFormatXYZDUV1 *vArray=W3DNEWARRAY VertexFormatXYZDUV1[vnum];		
		Vector3i v_index_array[MAX_SEGLINE_POLY_BUFFER_SIZE];
		
		// Vertex and triangle indices
		unsigned int vidx = 0;
		unsigned int tidx = 0;

// GENERALIZE FOR WHEN NO TEXTURE (DO NOT SET UV IN THESE CASES? NEED TO GENERALIZE FOR DIFFERENT TEXTURING MODES ANYWAY).

		// "Prime the pump" with two vertices (pick nearest point on each direction line):
		Vector3 &top_dir = intersection[1][TOP_EDGE].Direction;
		top = top_dir * Vector3::Dot_Product(points[0], top_dir);
		Vector3 &bottom_dir = intersection[1][BOTTOM_EDGE].Direction;
		bottom = bottom_dir * Vector3::Dot_Product(points[0], bottom_dir);
		vArray[vidx].x = top.X;
		vArray[vidx].y = top.Y;
		vArray[vidx].z = top.Z;
		vArray[vidx].u1 = u_values[0] + uv_offset.X;
		vArray[vidx].v1 = intersection[1][TOP_EDGE].TexV + uv_offset.Y;
		vidx++;
		vArray[vidx].x = bottom.X;
		vArray[vidx].y = bottom.Y;
		vArray[vidx].z = bottom.Z;
		vArray[vidx].u1 = u_values[1] + uv_offset.X;
		vArray[vidx].v1 = intersection[1][BOTTOM_EDGE].TexV + uv_offset.Y;
		vidx++;
		
		unsigned int last_top_vidx = 0;
		unsigned int last_bottom_vidx = 1;

		// Loop over intersections, create new vertices and triangles.
		unsigned int top_int_idx = 1;		// Skip "pre-first-point" dummy intersection
		unsigned int bottom_int_idx = 1;	// Skip "pre-first-point" dummy intersection
		pidx = 0;
		unsigned int residual_top_points = intersection[1][TOP_EDGE].PointCount;
		unsigned int residual_bottom_points = intersection[1][BOTTOM_EDGE].PointCount;

		// Reduce both pointcounts by the same amount so the smaller one is 1 (skip points)
		unsigned int delta = MIN(residual_top_points, residual_bottom_points) - 1;
		residual_top_points -= delta;
		residual_bottom_points -= delta;
		pidx += delta;

		for (; ; ) {

			if (residual_top_points == 1 && residual_bottom_points == 1) {
				// Advance both intersections, creating a tristrip segment
				v_index_array[tidx].I = last_top_vidx;
				v_index_array[tidx].J = last_bottom_vidx;
				v_index_array[tidx].K = vidx;
				tidx++;
				v_index_array[tidx].I = last_bottom_vidx;
				v_index_array[tidx].J = vidx + 1;
				v_index_array[tidx].K = vidx;
				tidx++;
				last_top_vidx = vidx;
				last_bottom_vidx = vidx + 1;

				// Advance both intersections.
				top_int_idx++;
				bottom_int_idx++;
				residual_top_points = intersection[top_int_idx][TOP_EDGE].PointCount;
				residual_bottom_points = intersection[bottom_int_idx][BOTTOM_EDGE].PointCount;

				// Advance point index (must do here because the new point index is used below):
				pidx++;

				// Generate two vertices for next point by picking nearest point on each direction line
				Vector3 &top_dir = intersection[top_int_idx][TOP_EDGE].Direction;
				top = top_dir * Vector3::Dot_Product(points[pidx], top_dir);
				Vector3 &bottom_dir = intersection[bottom_int_idx][BOTTOM_EDGE].Direction;
				bottom = bottom_dir * Vector3::Dot_Product(points[pidx], bottom_dir);

				vArray[vidx].x = top.X;
				vArray[vidx].y = top.Y;
				vArray[vidx].z = top.Z;
				vArray[vidx].u1 = u_values[0] + uv_offset.X;
				vArray[vidx].v1 = intersection[top_int_idx][TOP_EDGE].TexV + uv_offset.Y;
				vidx++;
				vArray[vidx].x = bottom.X;
				vArray[vidx].y = bottom.Y;
				vArray[vidx].z = bottom.Z;
				vArray[vidx].u1 = u_values[1] + uv_offset.X;
				vArray[vidx].v1 = intersection[bottom_int_idx][BOTTOM_EDGE].TexV + uv_offset.Y;
				vidx++;
			} else {
				// Exactly one of the pointcounts is greater than one - advance it and draw one triangle
				if (residual_top_points > 1) {
					// Draw one triangle (fan segment)
					v_index_array[tidx].I = last_top_vidx;
					v_index_array[tidx].J = last_bottom_vidx;
					v_index_array[tidx].K = vidx;
					tidx++;
					last_bottom_vidx = vidx;

					// Advance bottom intersection only
					residual_top_points--;
					bottom_int_idx++;
					residual_bottom_points = intersection[bottom_int_idx][BOTTOM_EDGE].PointCount;

					// Advance point index (must do here because the new point index is used below):
					pidx++;

					// Generate bottom vertex by picking nearest point on bottom direction line
					Vector3 &bottom_dir = intersection[bottom_int_idx][BOTTOM_EDGE].Direction;
					bottom = bottom_dir * Vector3::Dot_Product(points[pidx], bottom_dir);

					vArray[vidx].x = bottom.X;
					vArray[vidx].y = bottom.Y;
					vArray[vidx].z = bottom.Z;
					vArray[vidx].u1 = u_values[1] + uv_offset.X;
					vArray[vidx].v1 = intersection[bottom_int_idx][BOTTOM_EDGE].TexV + uv_offset.Y;					
					vidx++;
				} else {

					// residual_bottom_points > 1

					// Draw one triangle (fan segment)
					v_index_array[tidx].I = last_top_vidx;
					v_index_array[tidx].J = last_bottom_vidx;
					v_index_array[tidx].K = vidx;
					tidx++;
					last_top_vidx = vidx;

					// Advance top intersection only
					residual_bottom_points--;
					top_int_idx++;
					residual_top_points = intersection[top_int_idx][TOP_EDGE].PointCount;

					// Advance point index (must do here because the new point index is used below):
					pidx++;

					// Generate top vertex by picking nearest point on top direction line
					Vector3 &top_dir = intersection[top_int_idx][TOP_EDGE].Direction;
					top = top_dir * Vector3::Dot_Product(points[pidx], top_dir);
					vArray[vidx].x = top.X;
					vArray[vidx].y = top.Y;
					vArray[vidx].z = top.Z;
					vArray[vidx].u1 = u_values[0] + uv_offset.X;
					vArray[vidx].v1 = intersection[top_int_idx][TOP_EDGE].TexV + uv_offset.Y;
					vidx++;
				}
			}

			// Reduce both pointcounts by the same amount so the smaller one is 1 (skip points)
			delta = MIN(residual_top_points, residual_bottom_points) - 1;
			residual_top_points -= delta;
			residual_bottom_points -= delta;
			pidx += delta;

			// Exit conditions
			if (	(top_int_idx >= num_intersections[TOP_EDGE] && residual_top_points == 1) ||
					(bottom_int_idx >= num_intersections[BOTTOM_EDGE] && residual_bottom_points == 1)) {
				// Debugging check - if either intersection index is before end, both of them should be
				// and the points should be before the end.
				assert(top_int_idx == num_intersections[TOP_EDGE]);
				assert(bottom_int_idx == num_intersections[BOTTOM_EDGE]);
				assert(pidx == point_cnt - 1);
				break;
			}
		}		

		/*
		** Set color, opacity, vertex flags:
		*/
		
		// If color is not white or opacity not 100%, enable gradient in shader and in renderer - otherwise disable.		
		unsigned int rgba;
		rgba=DX8Wrapper::Convert_Color(Color,Opacity);
		bool rgba_all=(rgba==0xFFFFFFFF);

		// Enable sorting if sorting has not been disabled and line is translucent and alpha testing is not enabled.
		bool sorting = (!Is_Sorting_Disabled()) && (Shader.Get_Dst_Blend_Func() != ShaderClass::DSTBLEND_ZERO && Shader.Get_Alpha_Test() == ShaderClass::ALPHATEST_DISABLE);

		ShaderClass shader = Shader;
		shader.Set_Cull_Mode(ShaderClass::CULL_MODE_DISABLE);

		VertexMaterialClass *mat;		

		if (!rgba_all) {
			shader.Set_Primary_Gradient(ShaderClass::GRADIENT_MODULATE);			
			for (vidx = 0; vidx < vnum; vidx++)	vArray[vidx].diffuse=rgba;
			mat=VertexMaterialClass::Get_Preset(VertexMaterialClass::PRELIT_DIFFUSE);
		} else {
			shader.Set_Primary_Gradient(ShaderClass::GRADIENT_DISABLE);
			mat=VertexMaterialClass::Get_Preset(VertexMaterialClass::PRELIT_NODIFFUSE);
		}

		// If Texture is non-NULL enable texturing in shader - otherwise disable.
		if (Texture) {
			shader.Set_Texturing(ShaderClass::TEXTURING_ENABLE);			
		} else {
			shader.Set_Texturing(ShaderClass::TEXTURING_DISABLE);
		}


		/*
		** Render
		*/		
		
		DynamicVBAccessClass Verts((sorting?BUFFER_TYPE_DYNAMIC_SORTING:BUFFER_TYPE_DYNAMIC_DX8),dynamic_fvf_type,vnum);
		// Copy in the data to the  VB
		{
			DynamicVBAccessClass::WriteLockClass Lock(&Verts);
			unsigned int i;
			unsigned char *vb=(unsigned char*)Lock.Get_Formatted_Vertex_Array();			
			const FVFInfoClass& fvfinfo=Verts.FVF_Info();			

			for (i=0; i<vnum; i++)
			{
				// Copy Locations
				((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->X=vArray[i].x;
				((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->Y=vArray[i].y;
				((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->Z=vArray[i].z;
				*(unsigned int*)(vb+fvfinfo.Get_Diffuse_Offset())=vArray[i].diffuse;
				((Vector2*)(vb+fvfinfo.Get_Tex_Offset(0)))->U=vArray[i].u1;
				((Vector2*)(vb+fvfinfo.Get_Tex_Offset(0)))->V=vArray[i].v1;				
				vb+=fvfinfo.Get_FVF_Size();				
			}			
		} // copy
		
		DynamicIBAccessClass ib_access((sorting?BUFFER_TYPE_DYNAMIC_SORTING:BUFFER_TYPE_DYNAMIC_DX8),tidx*3);
		{
			unsigned int i;
			DynamicIBAccessClass::WriteLockClass lock(&ib_access);
			unsigned short* inds=lock.Get_Index_Array();

			for (i=0; i<tidx; i++)
			{
				*inds++=v_index_array[i].I;
				*inds++=v_index_array[i].J;
				*inds++=v_index_array[i].K;
			}
		}
		
		DX8Wrapper::Set_Index_Buffer(ib_access,0);
		DX8Wrapper::Set_Vertex_Buffer(Verts);				
		DX8Wrapper::Set_Material(mat);		
		DX8Wrapper::Set_Texture(0,Texture);
		DX8Wrapper::Set_Shader(shader);

		if (sorting) {	
			SortingRendererClass::Insert_Triangles(obj_sphere,0,tidx,0,vnum);
		} else {
			DX8Wrapper::Draw_Triangles(0,tidx,0,vnum);
		}
		
		REF_PTR_RELEASE(mat);
		delete [] vArray;

	}	// Chunking loop

	DX8Wrapper::Set_Transform(D3DTS_VIEW,view);

}


void SegLineRendererClass::subdivision_util(unsigned int point_cnt, const Vector3 *xformed_pts,
	const float *base_tex_v, unsigned int *p_sub_point_cnt, Vector3 *xformed_subdiv_pts,
	float *subdiv_tex_v)
{
	// CAUTION: freezing the random offsets will make it more readily apparent that the offsets
	// are in camera space rather than worldspace.
	int freeze_random = Is_Freeze_Random();
	Random3Class randomize;
	const float oo_int_max = 1.0f / (float)INT_MAX;
	Vector3SolidBoxRandomizer randomizer(Vector3(1,1,1));
	Vector3 randvec(0,0,0);
	unsigned int sub_pidx = 0;

	struct SegLineSubdivision {
		Vector3			StartPos;
		Vector3			EndPos;
		float				StartTexV;	// V texture coordinate of start point
		float				EndTexV;		// V texture coordinate of end point
		float				Rand;
		unsigned int	Level;		// Subdivision level
	};

	SegLineSubdivision stack[2 * MAX_SEGLINE_SUBDIV_LEVELS];	// Maximum number needed
	int tos = 0;

	for (unsigned int pidx = 0; pidx < point_cnt - 1; pidx++) {

		// Subdivide the (pidx, pidx + 1) segment. Produce pidx and all subdivided points up to
		// (not including) pidx + 1.
		tos = 0;
		stack[0].StartPos = xformed_pts[pidx];
		stack[0].EndPos = xformed_pts[pidx + 1];
		stack[0].StartTexV = base_tex_v[pidx];
		stack[0].EndTexV = base_tex_v[pidx + 1];
		stack[0].Rand = NoiseAmplitude;
		stack[0].Level = 0;

		for (; tos >= 0;) {
			if (stack[tos].Level == SubdivisionLevel) {
				// Generate point location and texture V coordinate
				xformed_subdiv_pts[sub_pidx] = stack[tos].StartPos;
				subdiv_tex_v[sub_pidx++] = stack[tos].StartTexV;

				// Pop
				tos--;
			} else {
				// Recurse down: pop existing entry and push two subdivided ones.
				if (freeze_random) {
					randvec.Set(randomize * oo_int_max, randomize * oo_int_max, randomize * oo_int_max);
				} else {
					randomizer.Get_Vector(randvec);
				}
				stack[tos + 1].StartPos = stack[tos].StartPos;
				stack[tos + 1].EndPos = (stack[tos].StartPos + stack[tos].EndPos) * 0.5f + randvec * stack[tos].Rand;
				stack[tos + 1].StartTexV = stack[tos].StartTexV;
				stack[tos + 1].EndTexV = (stack[tos].StartTexV + stack[tos].EndTexV) * 0.5f;
				stack[tos + 1].Rand = stack[tos].Rand * 0.5f;
				stack[tos + 1].Level = stack[tos].Level + 1;
				stack[tos].StartPos = stack[tos + 1].EndPos;
				// stack[tos].EndPos already has the right value
				stack[tos].StartTexV = stack[tos + 1].EndTexV;
				// stack[tos].EndTexV already has the right value
				stack[tos].Rand = stack[tos + 1].Rand;
				stack[tos].Level = stack[tos + 1].Level;
				tos++;
			}
		}
	}
	// Last point
	xformed_subdiv_pts[sub_pidx] = xformed_pts[point_cnt - 1];
	subdiv_tex_v[sub_pidx++] = base_tex_v[point_cnt - 1];

	// Output:
	*p_sub_point_cnt = sub_pidx;
}



#endif //0